package acm.pta13;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.BitSet;
import java.util.StringTokenizer;

//弗洛伊德+入度筛选+路径存储
public class 病毒溯源 {
    // 定义一个三维数组，用于存储图的信息，第一维表示起点，第二维表示终点，第三维的第一个元素表示距离，第二个元素表示前驱节点
    static int[][][] map;

    public static void main(String[] args) {
        // 创建 io.Reader 对象读取输入
        Reader sc = new Reader();
        // 读取节点数量
        int n = sc.nextInt();
        // 初始化图的邻接矩阵
        map = new int[n][n][2];
        // 创建 BitSet 对象，用于记录所有入度非0的点
        BitSet bitSet = new BitSet(n);
        // 读取每个节点的出边
        for (int i = 0; i < n; i++) {
            int m = sc.nextInt();
            for (int j = 0; j < m; j++) {
                int to = sc.nextInt();
                // 初始化距离为1，前驱节点为i
                map[i][to] = new int[]{1, i};
                // 标记该点
                bitSet.set(to);
            }
        }
        // 反转 BitSet，得到所有入度为0的点
        bitSet.flip(0, n);
        // 找到第一个入度为0的点，作为源点
        int s = bitSet.stream().iterator().nextInt();
        // 执行弗洛伊德算法，计算所有点对之间的最短路径
        floyd();
        // 找到从源点出发的最长路径的终点
        int max = s;
        for (int i = 0; i < map.length; i++) {
            if (map[s][i][0] > map[s][max][0]) max = i;
        }
        // 打印最长路径的长度，+1是因为要把起点也算上
        System.out.println(map[s][max][0] + 1);
        // 构建并打印最长路径
        StringBuilder builder = new StringBuilder();
        print(builder, max, s);
        builder.deleteCharAt(builder.length() - 1);
        System.out.println(builder.toString());
    }

    /**
     * 递归打印路径的方法
     *
     * @param builder 用于构建路径的 StringBuilder 对象
     * @param cur     当前节点
     * @param s       源点
     */
    public static void print(StringBuilder builder, int cur, int s) {
        // 如果当前节点就是源点，直接添加到路径中
        if (cur == s) {
            builder.append(cur).append(" ");
            return;
        }
        // 递归打印从源点到当前节点的前驱节点的路径
        print(builder, map[s][cur][1], s);
        // 添加当前节点到路径中
        builder.append(cur).append(" ");
    }

    /**
     * 弗洛伊德算法，计算所有点对之间的最短路径
     */
    public static void floyd() {
        // 遍历每一个节点，作为中间节点
        for (int k = 0; k < map.length; k++) {
            // 遍历每一个节点，作为起点
            for (int i = 0; i < map.length; i++) {
                // 遍历每一个节点，作为终点
                for (int j = 0; j < map.length; j++) {
                    // 如果起点和终点是同一个节点，或者起点到中间节点或中间节点到终点没有路径，跳过
                    if (map[i][k][0] == 0 || map[k][j][0] == 0 || i == j) continue;
                    // 计算新的路径长度
                    int newPath = map[i][k][0] + map[k][j][0];
                    // 如果起点到终点没有直接的路径，或者新的路径长度比原来的路径长度短，更新路径长度和前驱节点
                    if (map[i][j][0] == 0 || map[i][j][0] > newPath) {
                        map[i][j][0] = newPath;
                        map[i][j][1] = k;
                    }
                }
            }
        }
    }

    static class Reader {
        private BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        private StringTokenizer tokenizer = new StringTokenizer("");

        private String innerNextLine() {
            try {
                return reader.readLine();
            } catch (IOException ex) {
                return null;
            }
        }

        public boolean hasNext() {
            while (!tokenizer.hasMoreTokens()) {    //内存中没有
                String nextLine = innerNextLine();
                if (nextLine == null) {     //且没有下一行
                    return false;
                }
                tokenizer = new StringTokenizer(nextLine);  //读入一行
            }
            return true;
        }

        public String nextLine() {
            tokenizer = new StringTokenizer("");    //清空内存中的字符
            return innerNextLine();
        }

        public void clear() {
            tokenizer = new StringTokenizer("");
        }

        public String next() {
            hasNext();
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }
//    public BigInteger nextBigInt() {
//        return new BigInteger(next());
//    }
    }

}
